﻿// 0803train01.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;


/*
 n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。
你需要按照以下要求，给这些孩子分发糖果：
- 每个孩子至少分配到 1 个糖果。
- 相邻两个孩子评分更高的孩子会获得更多的糖果。
请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。

输入：ratings = [1,0,2]
输出：5
解释：你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。

 */

void solve01(vector<int>&ratings)
{
    vector<int>oh_vec = ratings;
    int vec_size = oh_vec.size();
    vector<int>result_vec(vec_size, 1);

    for (int i=1; i<vec_size; i++)
    {
        int curr_num = oh_vec[i];
        int prev_num = oh_vec[i - 1];
        if (curr_num > prev_num)
        {
            result_vec[i] = result_vec[i - 1] + 1;
        }
        //for------
    }

    for (int i=vec_size-2; i>=0; i--)
    {
        int curr_num = oh_vec[i];
        int next_num = oh_vec[i + 1];

        int curr_result = result_vec[i];
        int next_result = result_vec[i + 1];

        if (curr_num>next_num && curr_result <= next_result)
        {
            result_vec[i] = next_result + 1;
        }

        //for------
    }

    //for (auto&num:result_vec)
    //{
    //    cout << num << ' ';
    //}

    //cout << '\n';

    int result = 0;
    for (auto&num : result_vec)
    {
        result += num;
    }
    cout << result;
    //solve01
}


/*
 输入两个字符串S和L，都只包含小写字母，
 len(S) <= 100，len(L) <= 500000。判断S是否是L的有效子字符串。
- 判定规则：S中的每个字符在L中都能找到（可以不连续），
且S在L中字符的前后顺序与S中顺序要保持一致。
例如：
S = "ace"是L = "abcde"的一个子序列，且有效字符是a、c、e，
而"aec"不是有效子序列，且有效字符只有a、e（因为相对位置不同）。

输入
输入两个字符串S和L，都只包含小写字母，len(S) <= 100，len(L) <= 500000，先输入S再输入L
每个字符串占一行。
输出描述
S串最后一个有效字符在L中的位置，首位从0开始计算。无有效字符返回 -1

输入
ace
abcde
输出
4

 */


void solve02(string &mini_str, string&oh_str)
{
    int mini_index = 0;
    int result = -1;
    for (int i=0; i<oh_str.size(); i++)
    {
        //ace abcde
        char curr_char = oh_str[i];
        if (curr_char == mini_str[mini_index])
        {
        	result = i;
            mini_index++;
        }

        //for------
    }
    cout << result;
    //solve02
    //------
}


/*
疫情期间课堂的座位进行了特殊的调整，不能出现两个同学紧挨着，必须隔至少一个空位。
给你一个整数数组 desk 表示当前座位的占座情况，由若干 0 和 1 组成，
其中 0 表示没有占位，1 表示占位。在不改变原有座位秩序情况下，
还能安排坐几个人？

输入
第一行是个子数组表示作为占座情况，由若干 0 和 1 组成，其中 0 表示没有占位，1 表示占位
输出
输出数值表示还能坐几个人

输入
1,0,0,0,1
输出
1

 */

void solve03(vector<int>&oh_vec)
{
    int vec_size = oh_vec.size();
    int result = 0;

    for (int i=0; i<vec_size; i++)
    {
        int curr_num = oh_vec[i];
        if (i==0 && curr_num==0 && oh_vec[1]==0)
        {
            oh_vec[i] = 1;
            result += 1;
            continue;
        }

        if (i==vec_size-1 && curr_num==0 && oh_vec[i-1]==0)
        {
            oh_vec[i] = 1;
            result += 1;
            continue;
        }

        if (curr_num==0 && oh_vec[i-1]==0 && oh_vec[i+1] == 0)
        {
            oh_vec[i] = 1;
            result += 1;
        }
        //-----
    }
    cout << result;
	//solve03------
}



/*
1. 字符串 s，只包含 a-z，A-Z，+-；
2. 合法的整数包括 
1）正整数 一个或者多个0-9组成，如 0 2 3 002 102 
2）负整数 负号 - 开头，数字部分由一个或者多个0-9组成，如 -0 -012 -23 -00023

输入描述
包含数字的字符串

输出描述
所有整数的最小和

输入
bb1234aa
输出
10

输入
bb12-34aa
输出
-31
 */

bool IsDigit(char oh_char)
{
    return oh_char >= '0' && oh_char <= '9';
}

void solve04(string&oh_str)
{
    oh_str = oh_str + ' ';

    vector<int>up_vec;
    vector<int>down_vec;
    int vec_size = oh_str.size();

    for (int i=0; i < vec_size; i++)
    {
        char curr_char = oh_str[i];
        if (curr_char=='-' && IsDigit(oh_str[i+1]))
        {
            int curr_num = 0;
            i++;
            while (i<vec_size-1 && IsDigit(oh_str[i]))
            {
                int tmp_num = oh_str[i] - '0';
                curr_num = curr_num * 10 + tmp_num;
                
            	i++;
            }
            i--;
            curr_num = curr_num * (-1);
        	down_vec.push_back(curr_num);
        	continue;
        }

        if (IsDigit(curr_char))
        {
            int curr_num = curr_char - '0';
            up_vec.push_back(curr_num);
        }

        //for------
    }

    int result = 0;
    for (auto&num:up_vec)
    {
        result += num;
    }
    for (auto& num : down_vec)
    {
        cout << num << ' ';
        result += num;
    }

    cout << '\n';

    cout << result;
    //solve04
}



void solve041(string&oh_str)
{
    //防止数组越界
    oh_str = oh_str + ' ';
    int vec_size = oh_str.size();

    int sign = 1;
    vector<int>up_vec;
    vector<int>down_vec;

    int curr_num = 0;
    //"sd4f654df-8ss11d-fd1-7-7-1-175"
    for (int i=0; i<vec_size; i++)
    {
        char curr_char = oh_str[i];
        if (curr_char=='-')
        {
            if (IsDigit(oh_str[i + 1]))
            {
                sign = -1;
            }
        }
        if (IsDigit(curr_char))
        {
            if (sign>0)
            {
                int num = curr_char - '0';
                up_vec.push_back(num);
            }
            else
            {
                int num = curr_char - '0';
                curr_num = curr_num * 10 + num;
            }
        }
        else
        {
            if (curr_num!=0 && sign < 0)
            {
                //cout << "curr_num " << curr_num << endl;
                curr_num = curr_num * sign;
                down_vec.push_back(curr_num);
                curr_num = 0;
                if (curr_char!='-') sign = 1;
            }

        }
        //for------
    }

    int result = 0;
    for (auto&num:up_vec)
    {
        result += num;
    }

    for (auto&num:down_vec)
    {
        result += num;
    }
    cout << result;
    //solve041------
}


int main()
{
	{
        //bb1234aa
        //bb12-34aa
        string oh_str = "sd4f654df-8ss11d-fd1-7-7-1-175";
        //string oh_str;
        //cin >> oh_str;

        solve041(oh_str);
        return 0;
	}

	{
        string input;
        getline(cin, input);
        stringstream oh_sstream(input);
        string token;
        vector<int>oh_vec;
        while (getline(oh_sstream, token, ','))
        {
            oh_vec.push_back(stoi(token));
        }

        //for (auto&num:oh_vec)
        //{
        //    cout << num << ' ';
        //}

        //vector<int>oh_vec = { 1,0,0,0,1 };
        solve03(oh_vec);
        return 0;
	}

	{
        //ace abcde 4
        //fgh abcde -1
        //sdjflk sandlkhjfajdgosahgoag 8
        
        string mini_str = "sdjflk";
        string oh_str = "sandlkhjfajdgosahgoag";

        //string mini_str;
        //getline(cin, mini_str);

        //string oh_str;
        //getline(cin, oh_str);

        solve02(mini_str, oh_str);

        return 0;
	}

    //ratings = [1,0,2]
    //ratings = [1,2,2]
    //[1,2,87,87,87,2,1]
    vector<int>ratings = { 1,2,87,87,87,2,1 };

    solve01(ratings);
}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
